package Test.Test02;

import org.omg.CORBA.PUBLIC_MEMBER;

import java.util.*;

//https://www.nowcoder.com/exam/test/86453236/detail?pid=58083953

public class Test_mt_2024 {
    /**
     * 小美准备登录美团，需要输入密码，小美忘记了密码，只记得密码可能是
     * n
     * n 个字符串中的一个。小美会按照密码的长度从小到大依次尝试每个字符串，对于相同长度的字符串，小美随机尝试，
     * 并且相同的密码只会尝试一次。小美想知道，她最少需要尝试多少次才能登录成功，最多需要尝试多少次才能登录成功。
     *输入例子：
     * 4
     * ab
     * abc
     * ab
     * ac
     * ac
     * 输出例子：
     * 1 2
     * 例子说明：
     * 小美可能按照 ["ab", "ac", "abc"] 的顺序尝试，第一次尝试成功，也可能按照 ["ac", "ab", "abc"] 的顺序尝试，第二次尝试成功。
     * 小美在尝试 "ac" 发现不正确后不会继续尝试 "ac"。
     *
     * 小美不会重新尝试已经尝试过的字符串。成功登录后会立即停止尝试。
     * @param args
     */
    /*public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        scanner.nextLine(); // 消耗换行符
        String correctPassword = scanner.nextLine();
        Set<String> possiblePasswords = new HashSet<>();
        for (int i = 0; i < n; i++) {
            possiblePasswords.add(scanner.nextLine());
        }
        scanner.close();

        int ansLen = correctPassword.length();
        HashMap<Integer, Integer> map = new HashMap<>();
        for (String s : possiblePasswords) {
            map.merge(s.length(), 1, Integer::sum);
        }
        // 计算最少尝试次数
        int minTries = 0;

        // 计算最多尝试次数
        int maxTries = 0;
        for (int i = 1; i < ansLen; i++) {
            Integer count = map.getOrDefault(i, 0);
            minTries += count;
            maxTries += count;
        }
        Integer count = map.getOrDefault(ansLen, 0);
        minTries += 1;
        maxTries += count;

        // 输出结果
        System.out.println(minTries + " " + maxTries);
    }*/


/*    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt(); // 读取测试数据组数

        for (int t = 0; t < T; t++) {
            int n = scanner.nextInt(); // 数组长度
            int k = scanner.nextInt(); // 删除整个数组的花费系数
            int x = scanner.nextInt(); // 删除单个元素的花费

            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = scanner.nextLong();
            }

            // 使用 TreeSet 来存储数组中的元素
            TreeSet<Long> set = new TreeSet<>();
            for (long num : a) {
                set.add(num);
            }

            // 计算初始的 MEX
            long mex = findMex(set);

            // 初始总花费：删除整个数组
            long totalCost = mex * k;

            // 模拟删除单个元素的过程
            long currentCost = 0;
            for (int i = 0; i < n; i++) {
                // 删除当前元素
                set.remove(a[i]);

                // 更新 MEX
                mex = findMex(set);

                // 计算当前总花费
                currentCost += x;
                long newTotalCost = currentCost +  mex * k;

                // 更新最小总花费
                totalCost = Math.min(totalCost, newTotalCost);
            }

            System.out.println(totalCost);
        }

        scanner.close();
    }

    // 计算集合中的 MEX
    private static long findMex(Set<Long> set) {
        long mex = 0;
        while (set.contains(mex)) {
            mex++;
        }
        return mex;
    }*/
    public static Integer lastLeft;
    public static Integer lastRight;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int q = scanner.nextInt();

        int[] ribbon = new int[n];
        for (int i = 0; i < n; i++) {
            ribbon[i] = scanner.nextInt();
        }
        lastLeft = 0;
        lastRight = n - 1;
        for (int i = 0; i < q; i++) {
            char direction = scanner.next().charAt(0);
            int x = scanner.nextInt();
//            System.out.println(countColors(ribbon, n, x, direction));
            System.out.println(func(ribbon, n, x, direction));
        }

        scanner.close();
    }

    /**
     * @param ribbon    彩带颜色数组
     * @param n 彩带长度
     * @param x 剪的长度
     * @param direction 方向
//     * @param lastLeft  上一次剪的左边的位置
//     * @param lastRight 上一次剪的右边的位置
     * @return
     */
    private static int func(int[] ribbon, int n, int x, char direction) {
        Set<Integer> colors = new HashSet<>();
        int len = x % n == 0 ? n : x % n;
        int temp = 0;
        if ('L' == direction) {
            while (temp < len) {
                colors.add(ribbon[(lastLeft + temp) % n]);
                temp++;
            }
            lastLeft = (lastLeft + x) % n;
        }else{
            while (temp < len) {
                colors.add(ribbon[(lastRight + n - temp) % n]);
                temp++;
            }
            lastRight = (lastRight + n - x) % n;
        }
        return colors.size();
    }

    private static int countColors(int[] ribbon, int n, int x, char direction) {
        Set<Integer> colors = new HashSet<>();
        if (direction == 'L') {
            for (int i = 0; i < x; i++) {
                colors.add(ribbon[i % n]);
            }
        } else { // direction == 'R'
            for (int i = 0; i < x; i++) {
                colors.add(ribbon[(n - x + i) % n]);
            }
        }
        return colors.size();
    }
}
